﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using Ext.Net;
using Newtonsoft.Json.Linq;
using Utpl.Syllabus.ConfiguracionSistema.BL;
using Utpl.Syllabus.Framework;
using Utpl.Syllabus.Framework.Common;
using Utpl.Syllabus.Framework.Web.UI;
using Utpl.Syllabus.ModuloEstructuraCurricular.BL;
using Utpl.Syllabus.Nucleo.BL;
using Utpl.Syllabus.Reconocimiento.BL;
using Utpl.Syllabus.ControlesGenerales.Web;
using System.Configuration;
using Utpl.Syllabus.Framework.Core;
using Utpl.Syllabus.ModuloProgramaAcademico.BL;
namespace Utpl.Syllabus.Reconocimiento.Web
{
    [NotAuthorize]
    public partial class pgReconocimientos : SyPage
    {

        protected void Page_Load(object sender, EventArgs e)
        {
            try
            {
                if (!ExtNet.IsAjaxRequest)
                {
                    int rolId;
                    int.TryParse(Session[ConstantesBL.ROL].ToString(), out rolId);
                    var rol = SyllabusApplication.Instance().GetCurrentUser().Roles.FirstOrDefault(r => r.RolId == rolId);
                    var rolesRec = ConfigurationManager.AppSettings["RolesReconocimiento"].Split(',');
                    if (rolesRec.Count(p => p == rol.Codigo) == 1)
                    {
                        CargarDatosIniciales();
                    }
                    else
                    {
                        SessionGuard.AgainstNullSession(ConstantesBL.SESIONID);
                        SyPrincipal.Logout();

                        Response.Redirect(FormsAuthentication.LoginUrl);
                    }
                    //AgregarValidaciones();
                    
                    //var componentesDestino = ReconocimientoComponenteReconocidos.NewReconocimientoComponenteReconocidos();
                    //Session["ComponentesDestinoManual"] = componentesDestino;
                }
            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }
        }

        #region "Buscador"

        protected void StoreRefresh(object sender, StoreRefreshDataEventArgs e)
        {
            try
            {
                int periodo_acad_id = 0;
                int prm_numero_proceso = 0;
                int persona_id = 0;

                int.TryParse(e.Parameters["PeriodoAcademicoId"], out periodo_acad_id);

                int.TryParse(e.Parameters["NumeroProceso"], out prm_numero_proceso);
                int.TryParse(e.Parameters["PersonaId"], out persona_id);

                ReconocimientoEstudioCriteria criterio = ReconocimientoEstudioCriteria.New();
                criterio.PersonaId = persona_id;

                criterio.NumeroProceso = prm_numero_proceso;
                criterio.PeriodoAcademicoId = periodo_acad_id;
                criterio.Estado = e.Parameters["Estado"];
                stoReconocimiento.DataSource = ReconocimientoEstudioList.Get(criterio);
                stoReconocimiento.DataBind();

            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }
        }

        #endregion

        /// <summary>
        /// Carga datos iniciales de la matricula Academica
        /// </summary>
        public void CargarDatosIniciales()
        {
            //Lookup para cargar la Modalidad de Estudio
            stoModalidadB.DataSource = ModalidadEstudioLookup.GetNameValueList();
            stoModalidadB.DataBind();

            //Lookup para cargar Tipo de Estudio
            stoNivelAcademicoB.DataSource = NivelAcademicoLookup.GetNameValueList();
            stoNivelAcademicoB.DataBind();

            //Lookup Tipo de Unidad Academica
            var info = TipoUnidadAcademicaLookup.GetTipoUnidadAcademica().Single(
                tua => tua.Codigo == CodigosItems.ITEM_ESCUELA);
            stoUnidadAcademicaB.DataSource = UnidadAcademicaList.GetUnidadAcademicaList(info.Id);
            stoUnidadAcademicaB.DataBind();

            stoPeriodoAcademico.DataSource = PeriodoAcademicoList.GetPeriodosAcademicosActivos();
            stoPeriodoAcademico.DataBind();

            //Lookup Estado de Componente Educativo
            stoEstadoComponente.DataSource = EstadoRegistroAcademicoList.Get();// ComponenteEducativoEstadoLookup.GetNameValueList();
            stoEstadoComponente.DataBind();

            //Estado para el proceso de reconocimiento
            
            stoEstadoReconocimiento.DataSource = Utpl.Syllabus.Reconocimiento.BL.Util.EstadosReconocimiento();
            stoEstadoReconocimiento.DataBind();
        }
        /// <summary>
        /// Permite listar las variaciones
        /// </summary>
        /// <param name="nivelAcademicoId"></param>
        /// <param name="unidadAcademicaId"></param>
        /// <param name="modalidadId"></param>
        private void ListarVariaciones(int nivelAcademicoId, int unidadAcademicaId, int modalidadId)
        {
            var criterio = ProgramaEstructuraVariacionCriteria.New();
            criterio.UnidadAcademicaId = unidadAcademicaId == 0 ? null : (int?)unidadAcademicaId;
            criterio.ModalidadId = modalidadId == 0 ? null : (int?)modalidadId;
            criterio.NivelAcademicoId = nivelAcademicoId == 0 ? null : (int?)nivelAcademicoId;
            criterio.PeriodoFechaInicio = DateTime.Now;
            var listaVariaciones = ProgramaEstructuraVariacionList.Get(criterio).OrderBy(pecl => pecl.VariacionNombre);
            cbbProgramaAcademico.Reset();
            stoProgramaAcademico.DataSource = listaVariaciones;
            stoProgramaAcademico.DataBind();
        }

        /// <summary>
        /// Evento para cargar las variaciones de acuerdo a los parametros opcionales (Nivel Academico, Modalidad, Unidad Academica)
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void cbbProgramaAcademico_BeforeSelect(object sender, DirectEventArgs e)
        {
            try
            {
                int nivelAcademicoId, modalidadId, unidadAcademicaId;
                int.TryParse(e.ExtraParams["NivelAcademico"], out nivelAcademicoId);
                int.TryParse(e.ExtraParams["Modalidad"], out modalidadId);
                int.TryParse(e.ExtraParams["UnidadAcademica"], out unidadAcademicaId);

                ListarVariaciones(nivelAcademicoId, unidadAcademicaId, modalidadId);
                //var criterio = ProgramaEstructuraVariacionCriteria.New();
                //criterio.UnidadAcademicaId = unidadAcademicaId == 0 ? null : (int?)unidadAcademicaId;
                //criterio.ModalidadId = modalidadId == 0 ? null : (int?)modalidadId;
                //criterio.NivelAcademicoId = nivelAcademicoId == 0 ? null : (int?)nivelAcademicoId;
                //criterio.PeriodoFechaInicio = DateTime.Now;
                //var listaVariaciones = ProgramaEstructuraVariacionList.Get(criterio);
                //stoProgramaAcademico.DataSource = listaVariaciones;
                //stoProgramaAcademico.DataBind();
            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }
        }

        /// <summary>
        /// Evento que se da cuando se selecciona una variacion
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void cbbProgramaAcademico_Select(object sender, DirectEventArgs e)
        {
            try
            {
                //var nivelAcademico = e.ExtraParams["NivelAcademico"];
                var identificacion = e.ExtraParams["Identificacion"];
                //var modalidad = e.ExtraParams["Modalidad"];

                int variacionId,personaId;
                int.TryParse(e.ExtraParams["VariacionId"], out variacionId);
                int.TryParse(e.ExtraParams["PersonaId"], out personaId);
                if (ReconocimientoSolicitanteCmd.Verificar(personaId))
                {
                    ExtNet.Js.Call("Sy.showMsgAlerta", "El solicitante ya tiene un proceso de reconocimiento en estudio");
                    return;
                }
                else
                {
                    ListarProgramasOrigenGruposCreditos(variacionId, identificacion);
                }
            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }
        }

        void ListarProgramasOrigenGruposCreditos(int variacionId, string identificacion)
        {
            var estructuraVariacion = EstructuraCurricularVariacionSimpleInfo.Get(variacionId);
            var programaAcademicoInfo =
                ProgramaAcademicoInfo.GetProgramaAcademicoInfo(
                    estructuraVariacion.ProgramaAcademicoId);
            hddModalidad.SetValue(programaAcademicoInfo.ModalidadNombre);
            var criterio = PlanEstudioCriteria.New();
            criterio.CodigoNivelAcademico = programaAcademicoInfo.NivelAcademicoNombre;//"PREGRADO";
            criterio.Identificacion = identificacion;//"0704682012001";
            var listaPlanEstudiante = PlanEstudianteList.Get(criterio);
            stoProgramaOrigen.DataSource = listaPlanEstudiante;
            stoProgramaOrigen.DataBind();
            gpProgramOrigen.Disabled = false;
            //var componentesVariacion = estructuraVariacion.VariacionComponentes;

            stoGrupo.DataSource = estructuraVariacion.DistribucionGrupos;
            stoGrupo.DataBind();
        }

        /// <summary>
        /// Metodos que permite evaluar automaticamente si se le reconocen componentes en base a equivalencias.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnEvaluarAutomaticamente_Click(object sender, DirectEventArgs e)
        {
            try
            {
                var reconocimiento = Session["ReconocimientoEstudio"] as ReconocimientoEstudio;
                
                var identificacion = e.ExtraParams["Identificacion"];
                reconocimiento.Identificacion = identificacion;
                var proId = e.ExtraParams["ProgramaDestino"];
                int variacionId, personaId, periodoAcademicoId;
                int.TryParse(e.ExtraParams["PeriodoAcademicoId"], out periodoAcademicoId);
                int.TryParse(e.ExtraParams["VariacionId"], out variacionId);
                int.TryParse(e.ExtraParams["PersonaId"], out personaId);
                int id, ProId, grupoCreditoId, creditos, nota = 0, asignaturaId, nivel;
                int.TryParse(proId, out ProId);
                //var expediente = RegistroAcademicoResumenList.Get(personaId);

                var estructuraVariacion = EstructuraCurricularVariacionSimpleInfo.Get(variacionId);
                var criterio = EquivalenciaCriteria.New();
                criterio.VariacionId = variacionId;
                criterio.EstadoId = 1;


                var listaComponentesProgamaDestino = estructuraVariacion.VariacionComponentes;

                var equivalencias = EquivalenciaList.Get(criterio);
                bool encontrado = true;

                #region "Compara las equivalencias contra los componentes de la variacion seleccionada"
                foreach (var componente in listaComponentesProgamaDestino)
                {
                    foreach (var equivalencia in equivalencias)
                    {
                        if (componente.ComponenteEducativoId == equivalencia.ComponenteId)
                        {
                            if (ComponenteAprobadoCmd.Execute(personaId, componente.ComponenteEducativoId, variacionId))
                                break;
                            if (ComponenteMatriculadoCmd.Execute(personaId, componente.ComponenteEducativoId, variacionId, periodoAcademicoId))
                                break;
                            ReconocimientoComponenteNoReconocido reconocimientoComponenteNoReconocido;
                            var indiceCoe = -1;
                            var notaCoeOrigen = 0;
                            foreach (var coeOrigen in equivalencia.ComponentesOrigen)
                            {
                                encontrado = true;
                                reconocimientoComponenteNoReconocido = reconocimiento.ComponentesNoReconocidos.FirstOrDefault(cnr => cnr.AsignaturaId == coeOrigen.AsignaturaId);// .FindIndex(p => p.As == coeOrigen.AsignaturaId);
                                if (reconocimientoComponenteNoReconocido == null)
                                {
                                    encontrado = false;
                                    break;
                                }
                                if (equivalencia.ComponentesOrigen.Count == 1)
                                {
                                    nota = reconocimientoComponenteNoReconocido.Nota;
                                }
                            }
                            if (equivalencia.ComponentesOrigen.Count == 1 && encontrado)
                            {
                                notaCoeOrigen = nota;
                            }
                            if (encontrado)
                            {
                                var componenteReconocido = ReconocimientoComponenteReconocido.NewReconocimientoComponenteReconocido();
                                componenteReconocido.Codigo = equivalencia.CodigoComponente;
                                componenteReconocido.ComponenteId = equivalencia.ComponenteId;
                                componenteReconocido.Creditos = equivalencia.NumeroCreditos;
                                componenteReconocido.GrupoCredito = equivalencia.GrupoCredito;
                                componenteReconocido.GrupoCreditoId = equivalencia.GrupoCreditoId;
                                componenteReconocido.EquivalenciaId = equivalencia.Id;
                                componenteReconocido.Nota = notaCoeOrigen;
                                componenteReconocido.Nombre = equivalencia.NombreComponente;
                                componenteReconocido.Identificacion = identificacion;
                                componenteReconocido.ComponentesOrigen = equivalencia.ComponentesOrigen;
                                componenteReconocido.Usuario = SyllabusApplication.Instance().GetCurrentUser().Nombre;
                                reconocimiento.ComponentesReconocidos.Add(componenteReconocido);

                                foreach (var coeOrigen in equivalencia.ComponentesOrigen)
                                {
                                    reconocimientoComponenteNoReconocido = reconocimiento.ComponentesNoReconocidos.FirstOrDefault(cnr => cnr.AsignaturaId == coeOrigen.AsignaturaId);
                                    if (reconocimientoComponenteNoReconocido != null)
                                    {
                                        reconocimiento.ComponentesNoReconocidos.Remove(reconocimientoComponenteNoReconocido);
                                    }

                                }
                            }
                        }
                    }
                }

                #endregion

                #region "Compara las equivalencias contra los componentes aprobados en el sistema anterior"

                var listaEliminarNoRec = new List<int>();
                foreach (var componente in reconocimiento.ComponentesNoReconocidos)
                {
                    foreach (var equivalencia in equivalencias)
                    {
                        if (componente.AsignaturaId == equivalencia.ComponenteId)
                        {
                            //TODO: verificar con comand si ya tiene este componente aprobado.
                            /*if (ComponenteAprobadoCmd.Execute(personaId, componente.ComponenteEducativoId, variacionId))
                                break;
                            if (ComponenteMatriculadoCmd.Execute(personaId, componente.ComponenteEducativoId, variacionId, periodoAcademicoId))
                                break;*/
                            ReconocimientoComponenteNoReconocido reconocimientoComponenteNoReconocido;
                            var indiceCoe = -1;
                            var notaCoeOrigen = 0;
                            foreach (var coeOrigen in equivalencia.ComponentesOrigen)
                            {
                                encontrado = true;
                                reconocimientoComponenteNoReconocido = reconocimiento.ComponentesNoReconocidos.FirstOrDefault(cnr => cnr.AsignaturaId == coeOrigen.AsignaturaId);// .FindIndex(p => p.As == coeOrigen.AsignaturaId);
                                if (reconocimientoComponenteNoReconocido == null)
                                {
                                    encontrado = false;
                                    break;
                                }
                                if (equivalencia.ComponentesOrigen.Count == 1)
                                {
                                    nota = reconocimientoComponenteNoReconocido.Nota;
                                }
                            }
                            if (equivalencia.ComponentesOrigen.Count == 1 && encontrado)
                            {
                                notaCoeOrigen = nota;
                            }
                            if (encontrado)
                            {
                                var componenteReconocido = ReconocimientoComponenteReconocido.NewReconocimientoComponenteReconocido();
                                componenteReconocido.Codigo = equivalencia.CodigoComponente;
                                componenteReconocido.ComponenteId = equivalencia.ComponenteId;
                                componenteReconocido.Creditos = equivalencia.NumeroCreditos;
                                componenteReconocido.GrupoCredito = equivalencia.GrupoCredito;
                                componenteReconocido.GrupoCreditoId = equivalencia.GrupoCreditoId;
                                componenteReconocido.EquivalenciaId = equivalencia.Id;
                                componenteReconocido.Nota = notaCoeOrigen;
                                componenteReconocido.Identificacion = identificacion;
                                componenteReconocido.Nombre = equivalencia.NombreComponente;
                                componenteReconocido.Identificacion = identificacion;
                                componenteReconocido.ComponentesOrigen = equivalencia.ComponentesOrigen;
                                componenteReconocido.Usuario = SyllabusApplication.Instance().GetCurrentUser().Nombre;
                                reconocimiento.ComponentesReconocidos.Add(componenteReconocido);
                                listaEliminarNoRec.Add(componente.AsignaturaId);
                            }
                        }
                    }
                }

                foreach (var coeOrigen in listaEliminarNoRec)
                {
                   var reconocimientoComponenteNoReconocido = reconocimiento.ComponentesNoReconocidos.FirstOrDefault(cnr => cnr.AsignaturaId == coeOrigen);
                    if (reconocimientoComponenteNoReconocido != null)
                    {
                        reconocimiento.ComponentesNoReconocidos.Remove(reconocimientoComponenteNoReconocido);
                    }

                }

                #endregion

                //this.grpOrigen.Render();
                stoComponenteNoReconocidos.DataSource = reconocimiento.ComponentesNoReconocidos;
                stoComponenteNoReconocidos.DataBind();
                stoComponenteReconocidos.DataSource = reconocimiento.ComponentesReconocidos;
                stoComponenteReconocidos.DataBind();

                X.Js.Call("pgHomologacionDirecta.ContadorCoeReconocidoNoReconocido", (Operacion)Session["Operacion"] == Operacion.Editar ? 0 : 1);
            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }
        }

        /// <summary>
        /// Permite eliminar un componente reconocido y pasar sus componentes origen a los no reconocidos
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void EliminarComponenteReconocido(object sender, DirectEventArgs e)
        {
            try
            {
                int componenteId;
                int.TryParse(e.ExtraParams["ComponenteId"], out componenteId);
                var reconocimiento = Session["ReconocimientoEstudio"] as ReconocimientoEstudio;
                var componenteReconocido = reconocimiento.ComponentesReconocidos.FirstOrDefault(cr => cr.ComponenteId == componenteId);
                if (componenteReconocido != null)
                {
                    foreach (var coeOrigen in componenteReconocido.ComponentesOrigen)
                    {
                        var componenteOrigen = ReconocimientoComponenteNoReconocido.NewReconocimientoComponenteNoReconocido();

                        componenteOrigen.PlanEstudioId = coeOrigen.PlanEstudioId;
                        componenteOrigen.Nombre = coeOrigen.Nombre;
                        componenteOrigen.AsignaturaId = coeOrigen.AsignaturaId;
                        componenteOrigen.Codigo = coeOrigen.Codigo;
                        componenteOrigen.Creditos = coeOrigen.Creditos;
                        componenteOrigen.GrupoCreditoId = coeOrigen.GrupoCreditoId;
                        componenteOrigen.GrupoCredito = coeOrigen.GrupoCredito;
                        componenteOrigen.Nivel = coeOrigen.Nivel;
                        componenteOrigen.Nota = coeOrigen.Nota;

                        reconocimiento.ComponentesNoReconocidos.Add(componenteOrigen);
                    }
                    reconocimiento.ComponentesReconocidos.Remove(componenteReconocido);
                }
                stoComponenteReconocidos.DataSource = reconocimiento.ComponentesReconocidos;
                stoComponenteReconocidos.DataBind();
                stoComponenteNoReconocidos.DataSource = reconocimiento.ComponentesNoReconocidos;
                stoComponenteNoReconocidos.DataBind();
                X.Js.Call("pgHomologacionDirecta.ContadorCoeReconocidoNoReconocido",0);
            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }

        }

        /// <summary>
        /// Maneja la accion de Editar, Eliminar, Generar Reporte
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void gpReconocimiento_command_Click(object sender, DirectEventArgs e)
        {
            try
            {
                LimpiarCamposReconocimiento();
                int idRec;
                int.TryParse(e.ExtraParams["Id"], out idRec);
                var operacion = e.ExtraParams["Operacion"];
                var reconocimiento = ReconocimientoEstudio.GetReconocimientoEstudio(idRec);
                Session["ReconocimientoEstudio"] = reconocimiento;
                Session["IdReconocimientoEstudio"] = reconocimiento.NumeroProceso;
                switch (operacion)
                {
                    case "Editar":
                        Session["Operacion"] = Operacion.Editar;
                        break;
                    case "Eliminar":
                        btnEliminar.Show();
                        btnGuardar.Hide();
                        btnCancelar.Show();
                        btnFinalizar.Hide();
                        Session["Operacion"] = Operacion.Eliminar;
                        break;
                    case "Reporte":
                        Session["Operacion"] = Operacion.Reporte;
                        break;
                }
                if ((Operacion)Session["Operacion"] == Operacion.Reporte)
                {
                    X.Js.Call("pgHomologacionDirecta.generarReporte");
                }
                else
                {
                    ListarProgramasOrigenGruposCreditos(reconocimiento.VariacionProgramaAcademicoId,
                                                        reconocimiento.Identificacion);
                    
                    stoComponenteReconocidos.DataSource = reconocimiento.ComponentesReconocidos;
                    stoComponenteReconocidos.DataBind();
                    stoComponenteNoReconocidos.DataSource = reconocimiento.ComponentesNoReconocidos;
                    stoComponenteNoReconocidos.DataBind();
                    ListarVariaciones(0, 0, 0);
                    cbbProgramaAcademico.SetValue(reconocimiento.VariacionProgramaAcademicoId);
                    cbbPeriodoAcademico.SetValue(reconocimiento.PeriodoAcademicoId);
                    wccBuscadorBasicoPersona2.setValue(reconocimiento.PersonaId);

                    X.Js.Call("pgHomologacionDirecta.ContadorCoeReconocidoNoReconocido",0);
                    X.Js.Call("pgHomologacionDirecta.MostrarReconocimiento");
                    #region "Habilitar botones desmarcar"

                    foreach (var programaOrigen in reconocimiento.ProgramasAcademicosOrigen)
                    {
                        X.Js.Call("pgHomologacionDirecta.habilitarBtnToolbar", -1, true, programaOrigen.ProgramaAcademicoId);
                    }

                    #endregion

                    //frpResumen.Width = 380;
                    //X.Js.Alert(gpProgramOrigen.Width.ToString());
                }

            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }
        }

        /// <summary>
        /// Maneja la opcion de crear un nuevo reconocimiento
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnNuevo_Click(object sender, DirectEventArgs e)
        {
            try
            {
                LimpiarCamposReconocimiento();
                var reconocimiento = ReconocimientoEstudio.NewReconocimientoEstudio();
                Session["ReconocimientoEstudio"] = reconocimiento;
                Session["Operacion"] = Operacion.Nuevo;
                stoComponenteReconocidos.DataSource = reconocimiento.ComponentesReconocidos;
                stoComponenteReconocidos.DataBind();
                stoComponenteNoReconocidos.DataSource = reconocimiento.ComponentesNoReconocidos;
                stoComponenteNoReconocidos.DataBind();

                X.Js.Call("pgHomologacionDirecta.ContadorCoeReconocidoNoReconocido",1);
            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }
        }
        /// <summary>
        /// Limpiar campos de reconocimiento
        /// </summary>
        private void LimpiarCamposReconocimiento()
        {
            frpBuscadorProgramasAcademicos.Reset();
            frpVariacionPeriodo.Reset();
            X.Js.Call("pgHomologacionDirecta.LimpiarBuscadorPersona");
            Session.Remove("ReconocimientoEstudio");
            Session.Remove("Operacion");
            stoProgramaOrigen.RemoveAll();
            btnEliminar.Hide();
            btnGuardar.Show();
            btnCancelar.Show();
            btnFinalizar.Show();
        }

        /// <summary>
        /// Maneja la agregar asignaturas del plan seleccionado a los componente origen
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        [DirectMethod]
        public void AgregarAComponentesOrigen(string asignaturas)
        {
            try
            {
                int id;
                var reconocimiento = Session["ReconocimientoEstudio"] as ReconocimientoEstudio;
                #region "Mapeo de Asignaturas del plan a Componentes Origen"

                int planEstudioId, grupoCreditoId, creditos, nota, asignaturaId, nivel;
                //var records = JSON.Deserialize<Dictionary<string, string>[]>(e.ExtraParams["Asignaturas"]);
                var recordPlan = JSON.Deserialize<JObject>(asignaturas);

                #region "Plan Origen"

                int.TryParse(recordPlan["Id"].ToString(), out id);

                var planOrigen = ReconocimientoProgramaAcademico.NewReconocimientoProgramaAcademico();
                planOrigen.Nombre = recordPlan["Descripcion"].ToString();
                planOrigen.ProgramaAcademicoId = id;
                planOrigen.Codigo = recordPlan["Codigo"].ToString();
                planOrigen.Modalidad = recordPlan["Modalidad"].ToString();
                planOrigen.NivelAcademico = recordPlan["NivelAcademico"].ToString();
                planOrigen.TipoAprobacion = recordPlan["TipoAprobacion"].ToString();

                reconocimiento.ProgramasAcademicosOrigen.Add(planOrigen);

                #endregion

                var records = JSON.Deserialize<Dictionary<string, string>[]>(recordPlan["PlanAsignaturas"].ToString());
                foreach (Dictionary<string, string> record in records)
                {
                    int.TryParse(record["PlanEstudioId"], out planEstudioId);
                    int.TryParse(record["Nivel"], out nivel);
                    int.TryParse(record["AsignaturaId"], out asignaturaId);
                    int.TryParse(record["Nota"], out nota);
                    int.TryParse(record["Creditos"], out creditos);
                    int.TryParse(record["GrupoCreditoId"], out grupoCreditoId);

                    //VErifica si ya existe el componente en el listado
                    var existe = reconocimiento.ComponentesNoReconocidos.FirstOrDefault(cnr => cnr.AsignaturaId == asignaturaId);
                    if (existe == null)
                    {
                        var componenteOrigen =
                            ReconocimientoComponenteNoReconocido.NewReconocimientoComponenteNoReconocido();

                        componenteOrigen.PlanEstudioId = planEstudioId;
                        componenteOrigen.Nombre = record["Nombre"];
                        componenteOrigen.AsignaturaId = asignaturaId;
                        componenteOrigen.Codigo = record["Codigo"];
                        componenteOrigen.Creditos = record["Creditos"] == null ? null : (int?)creditos;
                        componenteOrigen.GrupoCreditoId = record["GrupoCreditoId"] == null ? null : (int?)grupoCreditoId;
                        componenteOrigen.GrupoCredito = record["GrupoCredito"];
                        componenteOrigen.Nivel = nivel;
                        componenteOrigen.Nota = nota;

                        reconocimiento.ComponentesNoReconocidos.Add(componenteOrigen);
                    }
                }



                #endregion

                stoComponenteNoReconocidos.DataSource = reconocimiento.ComponentesNoReconocidos;
                stoComponenteNoReconocidos.DataBind();
                X.Js.Call("pgHomologacionDirecta.ContadorCoeReconocidoNoReconocido",0);
            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }
        }
        /// <summary>
        /// Maneja la agregar asignaturas del plan seleccionado a los componente origen
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        [DirectMethod]
        public void QuitaComponentesdeOrigen(string asignaturas)
        {
            try
            {
                var reconocimiento = Session["ReconocimientoEstudio"] as ReconocimientoEstudio;

                #region "Mapeo de Asignaturas del plan a Componentes Origen"

                int planEstudioId, grupoCreditoId, creditos, nota, asignaturaId, nivel, id;
                var recordPlan = JSON.Deserialize<JObject>(asignaturas);

                int.TryParse(recordPlan["Id"].ToString(), out id);

                var programaOrigen =
                    reconocimiento.ProgramasAcademicosOrigen.FirstOrDefault(po => po.ProgramaAcademicoId == id);
                if (programaOrigen != null)
                {
                    reconocimiento.ProgramasAcademicosOrigen.Remove(programaOrigen);

                    var records =
                        JSON.Deserialize<Dictionary<string, string>[]>(recordPlan["PlanAsignaturas"].ToString());
                    foreach (Dictionary<string, string> record in records)
                    {
                        int.TryParse(record["AsignaturaId"], out asignaturaId);
                        var coeNoRec =
                            reconocimiento.ComponentesNoReconocidos.FirstOrDefault(
                                cnr => cnr.AsignaturaId == asignaturaId);
                        if (coeNoRec != null) reconocimiento.ComponentesNoReconocidos.Remove(coeNoRec);
                    }
                }


                #endregion
                hddOpcionRowSelect.SetValue(0);
                stoComponenteNoReconocidos.DataSource = reconocimiento.ComponentesNoReconocidos;
                stoComponenteNoReconocidos.DataBind();
                X.Js.Call("pgHomologacionDirecta.ContadorCoeReconocidoNoReconocido", (Operacion)Session["Operacion"]== Operacion.Editar?0:1);
            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }
        }
        /// <summary>
        /// Permite guardar el proceso de reconocimiento
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnGuardar_Click(object sender, DirectEventArgs e)
        {
            try
            {
                int id, periodoAcademicoId, estadoHomologacion, personaId, variacionId, grupoCreditoId, creditos, nota, asignaturaId, nivel, planEstudioId, tipoReconocimiento, estadoEquivalencia;
                var banFinaliza = false;

                var reconocimientoEstudio = Session["ReconocimientoEstudio"] as ReconocimientoEstudio;
                var operacion = (Operacion)Session["Operacion"];
                var op = e.ExtraParams["Opcion"];
                #region "Componentes Reconocidos"


                var rComponentesReconocidos = JSON.Deserialize<Dictionary<object, object>[]>(e.ExtraParams["ComponentesReconocidos"]);
                foreach (Dictionary<object, object> record in rComponentesReconocidos)
                {
                    int.TryParse(record["Id"].ToString(), out id);
                    int.TryParse(record["PlanEstudioId"].ToString(), out planEstudioId);
                    int.TryParse(record["EstadoHologacion"].ToString(), out estadoHomologacion);
                    int.TryParse(record["EstadoEquivalencia"].ToString(), out estadoEquivalencia);
                    int.TryParse(record["ComponenteId"].ToString(), out asignaturaId);
                    int.TryParse(record["Nota"].ToString(), out nota);
                    int.TryParse(record["Creditos"].ToString(), out creditos);
                    int.TryParse(record["TipoReconocimiento"].ToString(), out tipoReconocimiento);
                    int.TryParse(record["GrupoCreditoId"].ToString(), out grupoCreditoId);

                    //var componenteReconocido = ReconocimientoComponenteReconocido.NewReconocimientoComponenteReconocido();
                    var componenteReconocido = reconocimientoEstudio.ComponentesReconocidos.FirstOrDefault(cr => cr.ComponenteId == asignaturaId);
                    if (componenteReconocido != null)
                    {

                        componenteReconocido.Nombre = record["Nombre"].ToString();
                        componenteReconocido.ComponenteId = asignaturaId;
                        componenteReconocido.Codigo = record["Codigo"].ToString();
                        componenteReconocido.Creditos = creditos;
                        componenteReconocido.GrupoCreditoId = grupoCreditoId;
                        componenteReconocido.Nivel = 0; //nivel;
                        componenteReconocido.Nota = nota;
                        componenteReconocido.PlanEstudioId = planEstudioId;
                        componenteReconocido.TipoReconocimiento = tipoReconocimiento;
                        componenteReconocido.EstadoEquivalencia = estadoEquivalencia;
                        componenteReconocido.EstadoHologacion = estadoHomologacion;
                        componenteReconocido.Usuario = record["Usuario"].ToString();
                        //reconocimientoEstudio.ComponentesReconocidos.Add(componenteReconocido);
                    }
                }

                #endregion

                int.TryParse(e.ExtraParams["PeriodoAcademicoId"], out periodoAcademicoId);
                int.TryParse(e.ExtraParams["PersonaId"], out personaId);
                int.TryParse(e.ExtraParams["VariacionId"], out variacionId);

                //reconocimientoEstudio.ComponentesNoReconocidos = componentesNoReconocidos;
                //reconocimientoEstudio.ComponentesReconocidos = componentesReconocidos;
                reconocimientoEstudio.FechaActualizacion = DateTime.Now;
                if (operacion == Operacion.Nuevo)
                {
                    reconocimientoEstudio.FechaCreacion = DateTime.Now;
                    reconocimientoEstudio.UsuarioCrea = SyllabusApplication.Instance().GetCurrentUser().Nombre;
                    reconocimientoEstudio.UsuarioCreaId = SyllabusApplication.Instance().GetCurrentUser().Id;
                }

                reconocimientoEstudio.PeriodoAcademicoId = periodoAcademicoId;
                reconocimientoEstudio.PersonaId = personaId;
                //reconocimientoEstudio.ProgramasAcademicosOrigen = planesOrigen;
                //TODO cambias estos datos por los de la session
                reconocimientoEstudio.UsuarioActualiza = SyllabusApplication.Instance().GetCurrentUser().Nombre;
                reconocimientoEstudio.UsuarioActualizaId = SyllabusApplication.Instance().GetCurrentUser().Id;
                reconocimientoEstudio.VariacionProgramaAcademicoId = variacionId;
                reconocimientoEstudio.Modalidad = e.ExtraParams["Modalidad"];
                reconocimientoEstudio.Estado = EstadosReconocimiento.Registrada.ToString();
                if (reconocimientoEstudio.IsValid)
                {

                    if (op == "Finalizar")
                    {
                        reconocimientoEstudio.FechaFin = DateTime.Now;
                        reconocimientoEstudio.UsuarioFinaliza = SyllabusApplication.Instance().GetCurrentUser().Nombre;
                        reconocimientoEstudio.UsuarioFinalizaId = SyllabusApplication.Instance().GetCurrentUser().Id;
                        reconocimientoEstudio.Estado = EstadosReconocimiento.Evaluada.ToString();
                        banFinaliza = true;
                    }
                    reconocimientoEstudio = reconocimientoEstudio.Save();
                    reconocimientoEstudio.NumeroProceso = reconocimientoEstudio.Id;
                    if (banFinaliza)
                    {
                        ReconocimientoEstudioCmd.FinalizarEstudio(personaId, reconocimientoEstudio.Id,
                                                                  reconocimientoEstudio.VariacionProgramaAcademicoId,
                                                                  reconocimientoEstudio.PeriodoAcademicoId);
                    }
                }
                else
                {
                    ExtNet.Js.Call("Sy.showMsgAlerta", reconocimientoEstudio.GetBrokenRuleToString());
                    return;
                }
                if (banFinaliza)
                {
                    ExtNet.Js.Call("pgHomologacionDirecta.ExitoFinalizar");
                }
                else
                    ExtNet.Js.Call("pgHomologacionDirecta.ExitoGuardar");


            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }
        }
        /// <summary>
        /// Permite agregar un componente manualmente a los componentes reconocidos
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnAgregaComponenteManual_Click(object sender, DirectEventArgs e)
        {
            try
            {
                var reconocimiento = Session["ReconocimientoEstudio"] as ReconocimientoEstudio;

                int componenteId = 0, grupoCreditoId, nivel, nota, creditos, estado, planEstudioId, estadoEquivalencia;

                int.TryParse(e.ExtraParams["Estado"], out estado);
                int.TryParse(e.ExtraParams["AsignaturaId"], out componenteId);
                int.TryParse(e.ExtraParams["EstadoEquivalencia"], out estadoEquivalencia);
                int.TryParse(e.ExtraParams["PlanEstudioId"], out planEstudioId);
                int.TryParse(e.ExtraParams["Nivel"], out nivel);
                int.TryParse(e.ExtraParams["Nota"], out nota);
                int.TryParse(e.ExtraParams["Creditos"], out creditos);
                int.TryParse(e.ExtraParams["GrupoId"], out grupoCreditoId);
                var codigoComponente = e.ExtraParams["Codigo"];
                var nombreComponente = e.ExtraParams["Nombre"];
                var grupoCredito = e.ExtraParams["GrupoCredito"];
                var listaComponenteOrigen = new List<ComponenteOrigen>();
                var componenteOrigen = new ComponenteOrigen();

                componenteOrigen.AsignaturaId = componenteId;
                componenteOrigen.Id = componenteId;
                componenteOrigen.Nombre = nombreComponente;
                componenteOrigen.Codigo = codigoComponente;
                componenteOrigen.Creditos = creditos;
                componenteOrigen.GrupoCredito = grupoCredito;
                componenteOrigen.GrupoCreditoId = grupoCreditoId;
                componenteOrigen.Nivel = nivel;
                componenteOrigen.Nota = nota;
                componenteOrigen.PlanEstudioId = planEstudioId;

                listaComponenteOrigen.Add(componenteOrigen);

                var componenteReconocido = ReconocimientoComponenteReconocido.NewReconocimientoComponenteReconocido();

                componenteReconocido.Codigo = codigoComponente;
                componenteReconocido.ComponenteId = componenteId;
                componenteReconocido.Creditos = creditos;
                componenteReconocido.GrupoCredito = grupoCredito;
                componenteReconocido.GrupoCreditoId = grupoCreditoId;
                componenteReconocido.Nivel = nivel;
                componenteReconocido.Nota = nota;
                componenteReconocido.Nombre = nombreComponente;
                componenteReconocido.EstadoHologacion = estado;
                componenteReconocido.ComponentesOrigen = listaComponenteOrigen;
                componenteReconocido.PlanEstudioId = planEstudioId;
                componenteReconocido.TipoReconocimiento = (int)TipoReconocimiento.Manual;
                componenteReconocido.EstadoEquivalencia = estadoEquivalencia;
                componenteReconocido.Usuario = SyllabusApplication.Instance().GetCurrentUser().Nombre;

                reconocimiento.ComponentesReconocidos.Add(componenteReconocido);

                #region "Actualizar Store de componentes no Reconocidos"
                var coeNoRec =
                        reconocimiento.ComponentesNoReconocidos.FirstOrDefault(cnr => cnr.AsignaturaId == componenteId);
                if (coeNoRec != null) reconocimiento.ComponentesNoReconocidos.Remove(coeNoRec);
                stoComponenteNoReconocidos.DataSource = reconocimiento.ComponentesNoReconocidos;
                stoComponenteNoReconocidos.DataBind();
                #endregion

                stoComponenteReconocidos.DataSource = reconocimiento.ComponentesReconocidos;
                stoComponenteReconocidos.DataBind();

                X.Js.Call("pgHomologacionDirecta.ContadorCoeReconocidoNoReconocido", (Operacion)Session["Operacion"] == Operacion.Editar ? 0 : 1);
            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }
        }
        /// <summary>
        /// Cancela la accion actual, sea de finalizar,editar, nuevo
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnCancelar_Click(object sender, DirectEventArgs e)
        {
            try
            {
                LimpiarCamposReconocimiento();
                ExtNet.Js.Call("pgHomologacionDirecta.OcultarReconocimiento");
            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }
        }
        /// <summary>
        /// Finaliza el reconocimiento de estudios
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnEliminar_Click(object sender, DirectEventArgs e)
        {
            try
            {
                var reconocimientoEstudio = Session["ReconocimientoEstudio"] as ReconocimientoEstudio;
                reconocimientoEstudio.Delete();
                reconocimientoEstudio.Save();
                ExtNet.Js.Call("pgHomologacionDirecta.ExitoEliminar");
            }
            catch (Exception ex)
            {
                ManejadorExcepcionesHelper.CatchExceptionLoad(ex, this.ManejadorExcepciones, this.ManejadorMensajes);
            }
        }
    }

}